fix(scripts): resolve override members in the symbol-anchor accept set - #16895

Part of #16821

symbolResolutionClass resolved a member declared async / public / protected /
private, and returned unresolved-symbol for the same member declared override. One
token is added to the member matcher's accept set. Nothing that resolved before stops
resolving.

What the regex actually says — read in this branch, not inherited

Line numbers rot, so the site is identified by its token sequence, not its number. In
scripts/symbol-anchors.mjs, scriptSymbolClass builds five declaration matchers; the third
is the member matcher, and its modifier alternation read, verbatim:

(?:readonly |static |public |private |protected |abstract |declare |async |\* )*

Nine alternatives, hand-written, and override is the one TS member modifier absent from
them. Triage named line 336 for that matcher; in this branch it now sits at line 371 because
the explanatory comment landed above it. The alternation above is what identifies it.

The matcher one line up — the function / class / interface / type / enum /
namespace / module declaration matcher — does not carry override either, and correctly
so: override is not a legal modifier on any of those keywords. Only the member matcher was
wrong, and only the member matcher is touched.

Why this is a bug and not a shrug

The enumeration is hand-made and has now been demonstrated incomplete once. The card
raised "should the accept set be derived rather than enumerated?" as an open worry; reading
the source turns it into evidence. A hand-written list of nine that is missing one of the
things it is a list of is not a hypothetical failure mode — it is the observed one.

Two more facts that set the grade, both restated from the card and triage:

• The refused shape is the one the anchor rule exists for. An override member is where
  a subclass restates a base contract, which is where a citation most needs to be checkable.
• The failure is loud per author, silent in aggregate. The author sees a red. Nobody sees
  that the corpus censuses were structurally unable to contain an override member, and a
  census number reads like coverage.
• The unanchorable population is larger than the card knew. Measured on this branch:
  276 override member declarations under packages/, of which 207 are the
  static override metadata on CLI command classes (flags, examples, args,
  description). Every one of them was unanchorable by a symbol anchor.

The change

-    ...|private |protected |abstract |declare |...
+    ...|private |protected |override |abstract |declare |...

Plus the rationale comment above it, twelve self-test cases, and the battery-floor ledger row.
The alternation stays a free-order * group: TS fixes the written order (accessibility,
static, override, readonly, abstract), but pinning that order here would refuse a
spelling for being unidiomatic rather than for being absent, which is not this rule's job.

Census: every corpus that resolves through this matcher, before and after, same stroke

The matcher is shared, so a widened accept set moves every registered census at once. Three
gates import the resolver, not two — check-system-context-census registers a corpus through
the same symbolResolutionClass, and it has a --fix writer, so it is measured here too.

Taken on this branch at commit 1a33d4f4b3 (message-only amend to 7185a8bc1c, identical
tree), all three in one stroke before the edit and again after it:

diff over the full captured output of each gate reports no change. All three exit 0 before
and after.

Why nothing moved, stated rather than assumed. All three gates were already green, so
every anchor in every corpus already resolved; a purely additive accept set can only move an
anchor's class upward — unresolved to declaration, or literal to declaration — never
down. The only reclassification available was literal to declaration, and none of the ADR
corpus's 26 literal anchors names an override member, so no class changed anywhere.

And the 34 will not move by itself. The fix removes a structural exclusion; it does not
add anchors. That number rises only when an author writes an anchor naming an override
member — which, until this lands, they could not do.

Evidence

In place, in the worktree. The card's own repro copies the module to /tmp and breaks its
relative import of git-env.mjs; that failure is unrelated to the finding, so the resolver was
driven in place instead.

Before the change, against real tree files (not synthetic sources), the same probe after:

                              BEFORE        AFTER
turso-driver.ts#paginationTieBreaker    (protected override)      UNRESOLVED    declaration
turso-driver.ts#supports                (public override get)     UNRESOLVED    declaration
turso-driver.ts#bulkCreate              (override async)          literal       declaration
hook-wrappers.ts#name                   (override readonly)       UNRESOLVED    declaration
turso-driver.ts#noSuchMemberAtAll       (CONTROL: absent)         UNRESOLVED    UNRESOLVED

The control refuses in both legs, so the instrument is live in both. The bulkCreate row is
the class-upgrade case in the wild: it was resolving as literal, the weaker class, because
its name happens to appear as a quoted string in that file. That is the mechanism by which a
census could have moved — and the table above is the measurement showing that in these three
corpora it did not.

Ablation. With the twelve new self-test cases in place, override was removed from the
alternation again and the on-disk mutation verified by counting both the injected and the
removed token before running:

on-disk proof: with-override=0 (expect 0), without-override=1 (expect 1)
ABLATION EXIT=1
❌ symbol-anchors --self-test: a member declared `override` must resolve as a declaration

Restored from HEAD (not from the index) and re-verified: restored blob hash
734d554f099e8a583ba084774d058c12d692c532 equals the HEAD blob, git diff HEAD empty, and
the restore leg is green again. Predicted direction was "turns red"; observed direction was
"turns red".

Self-test. Twelve member spellings, each driven by name, each paired with its own negative
control riding the same source — plain, async, public async, protected async,
private, override, override async, protected override async, public override,
static override, override get, override readonly property. One token per finding is not
the repair: an enumeration is worth exactly what it is provoked with. The battery floor moves
69 to 93 with its ledger row, measured, not guessed.

Gates. All 31 families derived by scripts/pm/dispatch-gates.mjs for this change set were
run; 31 derived, 31 run, 0 NOT-MEASURED, 0 UNRUN, every one exit 0 — reconciled with
--ran. The three census gates above were run on top of that, since two of them are not in
the derived set for a scripts/** diff.

Card relation, and one residue to name

The relation is declared here in the body only, as Part of #16821 — the implementation is
complete and the card is left for the dispatching seat to close deliberately rather than by
merge parser.

⚠️ Residue, reported rather than rewritten. The two wip: commits at the base of this
branch carry a Refs #16821 trailer, written under a brief that turned out to be wrong:
check:partof-closing-keyword RULE 2 forbids any card-relation trailer in a commit
message, Refs included. The tip commit was amended clean before it was pushed
(commitRelations() returns [] for it); the two earlier ones were already pushed, and
rewriting a pushed branch is not an action this seat takes. They are named here so nobody has
to discover them.

Two things this PR does not do

1. It does not decide enumerate-vs-derive. Deriving the accept set is a rewrite of a
   shared resolver whose governing ruling is that a corpus joins by registration with no
   second implementation. That is a maintainer's call and is left open, with the evidence for
   it written into the comment at the site so the next author reads it there. The argument is
   in the report back to the dispatching seat.
2. It re-anchors nothing. [finding] SqlDriver reads keys off caller objects through (obj as any) at 7 sites while 3 parameter types declare none of them — a class, not a third coincidence (after #4311 tenancy, #16570 indexes) #16711's gate header keeps its class-level #TursoDriver
   anchor; this only makes the member-level form possible. Whether that header should be
   revisited is not decided here and is not touched.

Note on the illustration: the card's example anchor named initObjects in
packages/drivers/driver-turso/src/turso-driver.ts. On today's main that file names
initObjects only in comments — the declaration lives in the SqlDriver base — so that exact
anchor would not resolve regardless. The finding itself is unaffected and was re-verified
independently: that file still declares 27 override members of its own, three of which are
used as the live probe above.

No changeset: nothing published moves. Repo-root scripts/ is shipped by no package's
files[], the root manifest is private, and the resolver's exported names appear nowhere
under packages/ (checked with a firing positive control). skip-changeset applied.

Generated by Claude Code